// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_V8_INSPECTOR_H_
#define V8_V8_INSPECTOR_H_

#include <stdint.h>
#include <cctype>

#include <memory>

#include "v8.h" // NOLINT(build/include)

namespace v8_inspector {

namespace protocol {
    namespace Debugger {
        namespace API {
            class SearchMatch;
        }
    }
    namespace Runtime {
        namespace API {
            class RemoteObject;
            class StackTrace;
        }
    }
    namespace Schema {
        namespace API {
            class Domain;
        }
    }
} // namespace protocol

class V8_EXPORT StringView {
public:
    StringView()
        : m_is8Bit(true)
        , m_length(0)
        , m_characters8(nullptr)
    {
    }

    StringView(const uint8_t* characters, size_t length)
        : m_is8Bit(true)
        , m_length(length)
        , m_characters8(characters)
    {
    }

    StringView(const uint16_t* characters, size_t length)
        : m_is8Bit(false)
        , m_length(length)
        , m_characters16(characters)
    {
    }

    bool is8Bit() const { return m_is8Bit; }
    size_t length() const { return m_length; }

    // TODO(dgozman): add DCHECK(m_is8Bit) to accessors once platform can be used
    // here.
    const uint8_t* characters8() const { return m_characters8; }
    const uint16_t* characters16() const { return m_characters16; }

private:
    bool m_is8Bit;
    size_t m_length;
    union {
        const uint8_t* m_characters8;
        const uint16_t* m_characters16;
    };
};

class V8_EXPORT StringBuffer {
public:
    virtual ~StringBuffer() = default;
    virtual const StringView& string() = 0;
    // This method copies contents.
    static std::unique_ptr<StringBuffer> create(const StringView&);
};

class V8_EXPORT V8ContextInfo {
public:
    V8ContextInfo(v8::Local<v8::Context> context, int contextGroupId,
        const StringView& humanReadableName)
        : context(context)
        , contextGroupId(contextGroupId)
        , humanReadableName(humanReadableName)
        , hasMemoryOnConsole(false)
    {
    }

    v8::Local<v8::Context> context;
    // Each v8::Context is a part of a group. The group id must be non-zero.
    int contextGroupId;
    StringView humanReadableName;
    StringView origin;
    StringView auxData;
    bool hasMemoryOnConsole;

    static int executionContextId(v8::Local<v8::Context> context);

private:
    // Disallow copying and allocating this one.
    enum NotNullTagEnum { NotNullLiteral };
    void* operator new(size_t) = delete;
    void* operator new(size_t, NotNullTagEnum, void*) = delete;
    void* operator new(size_t, void*) = delete;
    V8ContextInfo(const V8ContextInfo&) = delete;
    V8ContextInfo& operator=(const V8ContextInfo&) = delete;
};

class V8_EXPORT V8StackTrace {
public:
    virtual StringView firstNonEmptySourceURL() const = 0;
    virtual bool isEmpty() const = 0;
    virtual StringView topSourceURL() const = 0;
    virtual int topLineNumber() const = 0;
    virtual int topColumnNumber() const = 0;
    virtual StringView topScriptId() const = 0;
    virtual StringView topFunctionName() const = 0;

    virtual ~V8StackTrace() = default;
    virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
    buildInspectorObject() const = 0;
    virtual std::unique_ptr<StringBuffer> toString() const = 0;

    // Safe to pass between threads, drops async chain.
    virtual std::unique_ptr<V8StackTrace> clone() = 0;
};

class V8_EXPORT V8InspectorSession {
public:
    virtual ~V8InspectorSession() = default;

    // Cross-context inspectable values (DOM nodes in different worlds, etc.).
    class V8_EXPORT Inspectable {
    public:
        virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
        virtual ~Inspectable() = default;
    };
    virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;

    // Dispatching protocol messages.
    static bool canDispatchMethod(const StringView& method);
    virtual void dispatchProtocolMessage(const StringView& message) = 0;
    virtual std::unique_ptr<StringBuffer> stateJSON() = 0;
    virtual std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
    supportedDomains() = 0;

    // Debugger actions.
    virtual void schedulePauseOnNextStatement(const StringView& breakReason,
        const StringView& breakDetails)
        = 0;
    virtual void cancelPauseOnNextStatement() = 0;
    virtual void breakProgram(const StringView& breakReason,
        const StringView& breakDetails)
        = 0;
    virtual void setSkipAllPauses(bool) = 0;
    virtual void resume() = 0;
    virtual void stepOver() = 0;
    virtual std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
    searchInTextByLines(const StringView& text, const StringView& query,
        bool caseSensitive, bool isRegex)
        = 0;

    // Remote objects.
    virtual std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
        v8::Local<v8::Context>, v8::Local<v8::Value>, const StringView& groupName,
        bool generatePreview)
        = 0;

    virtual bool unwrapObject(std::unique_ptr<StringBuffer>* error,
        const StringView& objectId, v8::Local<v8::Value>*,
        v8::Local<v8::Context>*,
        std::unique_ptr<StringBuffer>* objectGroup)
        = 0;
    virtual void releaseObjectGroup(const StringView&) = 0;
};

enum class V8ConsoleAPIType { kClear,
    kDebug,
    kLog,
    kInfo,
    kWarning,
    kError };

class V8_EXPORT V8InspectorClient {
public:
    virtual ~V8InspectorClient() = default;

    virtual void runMessageLoopOnPause(int contextGroupId) { }
    virtual void quitMessageLoopOnPause() { }
    virtual void runIfWaitingForDebugger(int contextGroupId) { }

    virtual void muteMetrics(int contextGroupId) { }
    virtual void unmuteMetrics(int contextGroupId) { }

    virtual void beginUserGesture() { }
    virtual void endUserGesture() { }

    virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>)
    {
        return nullptr;
    }
    virtual bool formatAccessorsAsProperties(v8::Local<v8::Value>)
    {
        return false;
    }
    virtual bool isInspectableHeapObject(v8::Local<v8::Object>) { return true; }

    virtual v8::Local<v8::Context> ensureDefaultContextInGroup(
        int contextGroupId)
    {
        return v8::Local<v8::Context>();
    }
    virtual void beginEnsureAllContextsInGroup(int contextGroupId) { }
    virtual void endEnsureAllContextsInGroup(int contextGroupId) { }

    virtual void installAdditionalCommandLineAPI(v8::Local<v8::Context>,
        v8::Local<v8::Object>) { }
    virtual void consoleAPIMessage(int contextGroupId,
        v8::Isolate::MessageErrorLevel level,
        const StringView& message,
        const StringView& url, unsigned lineNumber,
        unsigned columnNumber, V8StackTrace*) { }
    virtual v8::MaybeLocal<v8::Value> memoryInfo(v8::Isolate*,
        v8::Local<v8::Context>)
    {
        return v8::MaybeLocal<v8::Value>();
    }

    virtual void consoleTime(const StringView& title) { }
    virtual void consoleTimeEnd(const StringView& title) { }
    virtual void consoleTimeStamp(const StringView& title) { }
    virtual void consoleClear(int contextGroupId) { }
    virtual double currentTimeMS() { return 0; }
    typedef void (*TimerCallback)(void*);
    virtual void startRepeatingTimer(double, TimerCallback, void* data) { }
    virtual void cancelTimer(void* data) { }

    // TODO(dgozman): this was added to support service worker shadow page. We
    // should not connect at all.
    virtual bool canExecuteScripts(int contextGroupId) { return true; }

    virtual void maxAsyncCallStackDepthChanged(int depth) { }

    virtual std::unique_ptr<StringBuffer> resourceNameToUrl(
        const StringView& resourceName)
    {
        return nullptr;
    }
};

// These stack trace ids are intended to be passed between debuggers and be
// resolved later. This allows to track cross-debugger calls and step between
// them if a single client connects to multiple debuggers.
struct V8_EXPORT V8StackTraceId {
    uintptr_t id;
    std::pair<int64_t, int64_t> debugger_id;

    V8StackTraceId();
    V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id);
    ~V8StackTraceId() = default;

    bool IsInvalid() const;
};

class V8_EXPORT V8Inspector {
public:
    static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
    virtual ~V8Inspector() = default;

    // Contexts instrumentation.
    virtual void contextCreated(const V8ContextInfo&) = 0;
    virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
    virtual void resetContextGroup(int contextGroupId) = 0;
    virtual v8::MaybeLocal<v8::Context> contextById(int contextId) = 0;

    // Various instrumentation.
    virtual void idleStarted() = 0;
    virtual void idleFinished() = 0;

    // Async stack traces instrumentation.
    virtual void asyncTaskScheduled(const StringView& taskName, void* task,
        bool recurring)
        = 0;
    virtual void asyncTaskCanceled(void* task) = 0;
    virtual void asyncTaskStarted(void* task) = 0;
    virtual void asyncTaskFinished(void* task) = 0;
    virtual void allAsyncTasksCanceled() = 0;

    virtual V8StackTraceId storeCurrentStackTrace(
        const StringView& description)
        = 0;
    virtual void externalAsyncTaskStarted(const V8StackTraceId& parent) = 0;
    virtual void externalAsyncTaskFinished(const V8StackTraceId& parent) = 0;

    // Exceptions instrumentation.
    virtual unsigned exceptionThrown(
        v8::Local<v8::Context>, const StringView& message,
        v8::Local<v8::Value> exception, const StringView& detailedMessage,
        const StringView& url, unsigned lineNumber, unsigned columnNumber,
        std::unique_ptr<V8StackTrace>, int scriptId)
        = 0;
    virtual void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
        const StringView& message)
        = 0;

    // Connection.
    class V8_EXPORT Channel {
    public:
        virtual ~Channel() = default;
        virtual void sendResponse(int callId,
            std::unique_ptr<StringBuffer> message)
            = 0;
        virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
        virtual void flushProtocolNotifications() = 0;
    };
    virtual std::unique_ptr<V8InspectorSession> connect(
        int contextGroupId, Channel*, const StringView& state)
        = 0;

    // API methods.
    virtual std::unique_ptr<V8StackTrace> createStackTrace(
        v8::Local<v8::StackTrace>)
        = 0;
    virtual std::unique_ptr<V8StackTrace> captureStackTrace(bool fullStack) = 0;
};

} // namespace v8_inspector

#endif // V8_V8_INSPECTOR_H_
